home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevmem.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-26  |  12.0 KB  |  378 lines
  1. /* Copyright (C) 1989, 1995 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevmem.c */
  20. /* Generic "memory" (stored bitmap) device */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gserrors.h"
  24. #include "gsstruct.h"
  25. #include "gxdevice.h"
  26. #include "gxdevmem.h"            /* semi-public definitions */
  27. #include "gdevmem.h"            /* private definitions */
  28.  
  29. /* Structure descriptor */
  30. public_st_device_memory();
  31.  
  32. /* GC procedures */
  33. #define mptr ((gx_device_memory *)vptr)
  34. private ENUM_PTRS_BEGIN(device_memory_enum_ptrs) {
  35.     return (*st_device_forward.enum_ptrs)(vptr, sizeof(gx_device_forward), index-2, pep);
  36.     }
  37.     case 0: ENUM_RETURN((mptr->foreign_bits ? NULL : (void *)mptr->base));
  38.     ENUM_STRING_PTR(1, gx_device_memory, palette);
  39. ENUM_PTRS_END
  40. private RELOC_PTRS_BEGIN(device_memory_reloc_ptrs) {
  41.     if ( !mptr->foreign_bits )
  42.     {    byte *base_old = mptr->base;
  43.         long reloc;
  44.         int y;
  45.         RELOC_PTR(gx_device_memory, base);
  46.         reloc = base_old - mptr->base;
  47.         for ( y = 0; y < mptr->height; y++ )
  48.           mptr->line_ptrs[y] -= reloc;
  49.         /* Relocate line_ptrs, which also points into the data area. */
  50.         mptr->line_ptrs = (byte **)((byte *)mptr->line_ptrs - reloc);
  51.     }
  52.     RELOC_CONST_STRING_PTR(gx_device_memory, palette);
  53.     (*st_device_forward.reloc_ptrs)(vptr, sizeof(gx_device_forward), gcst);
  54. } RELOC_PTRS_END
  55. #undef mptr
  56.  
  57. /* Define the palettes for monobit devices. */
  58. private const byte b_w_palette_string[6] = { 0xff,0xff,0xff, 0,0,0 };
  59. const gs_const_string mem_mono_b_w_palette = { b_w_palette_string, 6 };
  60. private const byte w_b_palette_string[6] = { 0,0,0, 0xff,0xff,0xff };
  61. const gs_const_string mem_mono_w_b_palette = { w_b_palette_string, 6 };
  62.  
  63. /* ------ Generic code ------ */
  64.  
  65. /* Return the appropriate memory device for a given */
  66. /* number of bits per pixel (0 if none suitable). */
  67. const gx_device_memory *
  68. gdev_mem_device_for_bits(int bits_per_pixel)
  69. {    switch ( bits_per_pixel )
  70.        {
  71.     case 1: return &mem_mono_device;
  72.     case 2: return &mem_mapped2_device;
  73.     case 4: return &mem_mapped4_device;
  74.     case 8: return &mem_mapped8_device;
  75.     case 16: return &mem_true16_device;
  76.     case 24: return &mem_true24_device;
  77.     case 32: return &mem_true32_device;
  78.     default: return 0;
  79.        }
  80. }
  81. /* Do the same for a word-oriented device. */
  82. const gx_device_memory *
  83. gdev_mem_word_device_for_bits(int bits_per_pixel)
  84. {    switch ( bits_per_pixel )
  85.        {
  86.     case 1: return &mem_mono_word_device;
  87.     case 2: return &mem_mapped2_word_device;
  88.     case 4: return &mem_mapped4_word_device;
  89.     case 8: return &mem_mapped8_word_device;
  90.     case 24: return &mem_true24_word_device;
  91.     case 32: return &mem_true32_word_device;
  92.     default: return 0;
  93.        }
  94. }
  95.  
  96. /* Make a memory device. */
  97. /* Note that the default for monobit devices is white = 0, black = 1. */
  98. void
  99. gs_make_mem_device(gx_device_memory *dev, const gx_device_memory *mdproto,
  100.   gs_memory_t *mem, int page_device, gx_device *target)
  101. {    *dev = *mdproto;
  102.     dev->memory = mem;
  103.     dev->stype = &st_device_memory;
  104.     switch ( page_device )
  105.       {
  106.       case -1:
  107.         dev->std_procs.get_page_device = gx_default_get_page_device;
  108.         break;
  109.       case 1:
  110.         dev->std_procs.get_page_device = gx_page_device_get_page_device;
  111.         break;
  112.       }
  113.     dev->target = target;
  114.     if ( target != 0 )
  115.       {    /* Forward the color mapping operations to the target. */
  116.         gx_device_forward_color_procs((gx_device_forward *)dev);
  117.       }
  118.     if ( dev->color_info.depth == 1 )
  119.       gdev_mem_mono_set_inverted(dev,
  120.         (target == 0 ||
  121.          (*dev_proc(target, map_rgb_color))
  122.            (target, (gx_color_value)0, (gx_color_value)0,
  123.             (gx_color_value)0) != 0));
  124. }
  125. /* Make a monobit memory device.  This is never a page device. */
  126. /* Note that white=0, black=1. */
  127. void
  128. gs_make_mem_mono_device(gx_device_memory *dev, gs_memory_t *mem,
  129.   gx_device *target)
  130. {    *dev = mem_mono_device;
  131.     dev->memory = mem;
  132.     dev->std_procs.get_page_device = gx_default_get_page_device;
  133.     mdev->target = target;
  134.     gdev_mem_mono_set_inverted(dev, true);
  135. }
  136.  
  137.  
  138. /* Define whether a monobit memory device is inverted (black=1). */
  139. void
  140. gdev_mem_mono_set_inverted(gx_device_memory *dev, bool black_is_1)
  141. {    if ( black_is_1 )
  142.       dev->palette = mem_mono_b_w_palette;
  143.     else
  144.       dev->palette = mem_mono_w_b_palette;
  145. }
  146.  
  147. /* Compute the size of the bitmap storage, */
  148. /* including the space for the scan line pointer table. */
  149. /* Note that scan lines are padded to a multiple of align_bitmap_mod bytes, */
  150. /* and additional padding may be needed if the pointer table */
  151. /* must be aligned to an even larger modulus. */
  152. private ulong
  153. mem_bitmap_bits_size(const gx_device_memory *dev, int width, int height)
  154. {    return round_up((ulong)height *
  155.               bitmap_raster(width * dev->color_info.depth),
  156.             max(align_bitmap_mod, arch_align_ptr_mod));
  157. }
  158. ulong
  159. gdev_mem_data_size(const gx_device_memory *dev, int width, int height)
  160. {        return mem_bitmap_bits_size(dev, width, height) +
  161.        (ulong)height * sizeof(byte *);
  162.  
  163. }
  164. /*
  165.  * Do the inverse computation: given a width (in pixels) and a buffer size,
  166.  * compute the maximum height.
  167.  */
  168. int
  169. gdev_mem_max_height(const gx_device_memory *dev, int width, ulong size)
  170. {    ulong max_height = size /
  171.       (bitmap_raster(width * dev->color_info.depth) + sizeof(byte *));
  172.     int height = (int)min(max_height, max_int);
  173.  
  174.     /*
  175.      * Because of alignment rounding, the just-computed height might
  176.      * be too large by a small amount.  Adjust it the easy way.
  177.      */
  178.     while ( gdev_mem_data_size(dev, width, height) > size )
  179.       --height;
  180.     return height;
  181. }
  182.  
  183. /* Open a memory device, allocating the data area if appropriate, */
  184. /* and create the scan line table. */
  185. private void mem_set_line_ptrs(P3(gx_device_memory *, byte **, byte *));
  186. int
  187. mem_open(gx_device *dev)
  188. {    if ( mdev->bitmap_memory != 0 )
  189.     {    /* Allocate the data now. */
  190.         ulong size = gdev_mem_bitmap_size(mdev);
  191.         if ( (uint)size != size )
  192.             return_error(gs_error_limitcheck);
  193.         mdev->base = gs_alloc_bytes(mdev->bitmap_memory, (uint)size,
  194.                         "mem_open");
  195.         if ( mdev->base == 0 )
  196.             return_error(gs_error_VMerror);
  197.         mdev->foreign_bits = false;
  198.     }
  199. /*
  200.  * Macro for adding an offset to a pointer when setting up the
  201.  * scan line table.  This isn't just pointer arithmetic, because of
  202.  * the segmenting considerations discussed in gdevmem.h.
  203.  */
  204. #define huge_ptr_add(base, offset)\
  205.    ((void *)((byte huge *)(base) + (offset)))
  206.     mem_set_line_ptrs(mdev,
  207.               huge_ptr_add(mdev->base,
  208.                        mem_bitmap_bits_size(mdev, mdev->width,
  209.                                 mdev->height)),
  210.               mdev->base);
  211.     return 0;
  212. }
  213. /* Set up the scan line pointers of a memory device. */
  214. /* Sets line_ptrs, base, raster; uses width, height, color_info.depth. */
  215. private void
  216. mem_set_line_ptrs(gx_device_memory *devm, byte **line_ptrs, byte *base)
  217. {    byte **pptr = devm->line_ptrs = line_ptrs;
  218.     byte **pend = pptr + devm->height;
  219.     byte *scan_line = devm->base = base;
  220.     uint raster = devm->raster = gdev_mem_raster(devm);
  221.  
  222.     while ( pptr < pend )
  223.        {    *pptr++ = scan_line;
  224.         scan_line = huge_ptr_add(scan_line, raster);
  225.        }
  226. }
  227.  
  228. /* Return the initial transformation matrix */
  229. void
  230. mem_get_initial_matrix(gx_device *dev, gs_matrix *pmat)
  231. {    pmat->xx = mdev->initial_matrix.xx;
  232.     pmat->xy = mdev->initial_matrix.xy;
  233.     pmat->yx = mdev->initial_matrix.yx;
  234.     pmat->yy = mdev->initial_matrix.yy;
  235.     pmat->tx = mdev->initial_matrix.tx;
  236.     pmat->ty = mdev->initial_matrix.ty;
  237. }
  238.  
  239. /* Test whether a device is a memory device */
  240. bool
  241. gs_device_is_memory(const gx_device *dev)
  242. {    /* We can't just compare the procs, or even an individual proc, */
  243.     /* because we might be tracing.  Instead, check the identity of */
  244.     /* the device name. */
  245.     const gx_device_memory *bdev =
  246.       gdev_mem_device_for_bits(dev->color_info.depth);
  247.     if ( bdev != 0 && bdev->dname == dev->dname )
  248.       return true;
  249.         bdev = gdev_mem_word_device_for_bits(dev->color_info.depth);
  250.     return (bdev != 0 && bdev->dname == dev->dname);
  251. }
  252.  
  253. /* Close a memory device, freeing the data area if appropriate. */
  254. int
  255. mem_close(gx_device *dev)
  256. {    if ( mdev->bitmap_memory != 0 )
  257.       gs_free_object(mdev->bitmap_memory, mdev->base, "mem_close");
  258.     return 0;
  259. }
  260.  
  261. /* Copy a scan line to a client. */
  262. #undef chunk
  263. #define chunk byte
  264. int
  265. mem_get_bits(gx_device *dev, int y, byte *str, byte **actual_data)
  266. {    byte *src;
  267.     if ( y < 0 || y >= dev->height )
  268.         return_error(gs_error_rangecheck);
  269.     src = scan_line_base(mdev, y);
  270.     if ( actual_data == 0 )
  271.         memcpy(str, src, gx_device_raster(dev, 0));
  272.     else
  273.         *actual_data = src;
  274.     return 0;
  275. }
  276.  
  277. #if !arch_is_big_endian
  278.  
  279. /* Swap byte order in a rectangular subset of a bitmap. */
  280. /* If store = true, assume the rectangle will be overwritten, */
  281. /* so don't swap any bytes where it doesn't matter. */
  282. /* The caller has already done a fit_fill or fit_copy. */
  283. void
  284. mem_swap_byte_rect(byte *base, uint raster, int x, int w, int h, bool store)
  285. {    int xbit = x & 31;
  286.     if ( store )
  287.       {    if ( xbit + w > 64 )
  288.           {    /* Operation spans multiple words. */
  289.             /* Just swap the words at the left and right edges. */
  290.             if ( xbit != 0 )
  291.               mem_swap_byte_rect(base, raster, x, 1, h, false);
  292.             x += w - 1;
  293.             xbit = x & 31;
  294.             if ( xbit == 31 )
  295.               return;
  296.             w = 1;
  297.           }
  298.       }
  299.     /* Swap the entire rectangle (or what's left of it). */
  300.       {    byte *row = base + ((x >> 5) << 2);
  301.         int nw = (xbit + w + 31) >> 5;
  302.         int ny;
  303.         for ( ny = h; ny > 0; row += raster, --ny )
  304.           {    int nx = nw;
  305.             bits32 *pw = (bits32 *)row;
  306.             do
  307.               {    bits32 w = *pw;
  308.                 *pw++ = (w >> 24) + ((w >> 8) & 0xff00) +
  309.                   ((w & 0xff00) << 8) + (w << 24);
  310.               }
  311.             while ( --nx);
  312.           }
  313.       }
  314. }
  315.  
  316. /* Copy a word-oriented scan line to the client, swapping bytes as needed. */
  317. int
  318. mem_word_get_bits(gx_device *dev, int y, byte *str, byte **actual_data)
  319. {    byte *src;
  320.     uint raster = gx_device_raster(dev, 0);    /* only doing 1 scan line */
  321.     if ( y < 0 || y >= dev->height )
  322.       return_error(gs_error_rangecheck);
  323.     src = scan_line_base(mdev, y);
  324.     /* We use raster << 3 rather than dev->width so that */
  325.     /* the right thing will happen if depth > 1. */
  326.     mem_swap_byte_rect(src, raster, 0, raster << 3, 1, false);
  327.     memcpy(str, src, raster);
  328.     if ( actual_data != 0 )
  329.       *actual_data = str;
  330.     mem_swap_byte_rect(src, raster, 0, raster << 3, 1, false);
  331.     return 0;
  332. }
  333.  
  334. #endif                /* !arch_is_big_endian */
  335.  
  336. /* Map a r-g-b color to a color index for a mapped color memory device */
  337. /* (2, 4, or 8 bits per pixel.) */
  338. /* This requires searching the palette. */
  339. gx_color_index
  340. mem_mapped_map_rgb_color(gx_device *dev, gx_color_value r, gx_color_value g,
  341.   gx_color_value b)
  342. {    byte br = gx_color_value_to_byte(r);
  343.     byte bg = gx_color_value_to_byte(g);
  344.     byte bb = gx_color_value_to_byte(b);
  345.     register const byte *pptr = mdev->palette.data;
  346.     int cnt = mdev->palette.size;
  347.     const byte *which = 0;        /* initialized only to pacify gcc */
  348.     int best = 256*3;
  349.  
  350.     while ( (cnt -= 3) >= 0 )
  351.        {    register int diff = *pptr - br;
  352.         if ( diff < 0 ) diff = -diff;
  353.         if ( diff < best )    /* quick rejection */
  354.            {    int dg = pptr[1] - bg;
  355.             if ( dg < 0 ) dg = -dg;
  356.             if ( (diff += dg) < best )    /* quick rejection */
  357.                {    int db = pptr[2] - bb;
  358.                 if ( db < 0 ) db = -db;
  359.                 if ( (diff += db) < best )
  360.                     which = pptr, best = diff;
  361.                }
  362.            }
  363.         pptr += 3;
  364.        }
  365.     return (gx_color_index)((which - mdev->palette.data) / 3);
  366. }
  367.  
  368. /* Map a color index to a r-g-b color for a mapped color memory device. */
  369. int
  370. mem_mapped_map_color_rgb(gx_device *dev, gx_color_index color,
  371.   gx_color_value prgb[3])
  372. {    const byte *pptr = mdev->palette.data + (int)color * 3;
  373.     prgb[0] = gx_color_value_from_byte(pptr[0]);
  374.     prgb[1] = gx_color_value_from_byte(pptr[1]);
  375.     prgb[2] = gx_color_value_from_byte(pptr[2]);
  376.     return 0;
  377. }
  378.